use crate::db::{query, sqlite, query::PaginationParams, models::Notice};
use crate::ui::tools;
use crate::crawler::get_web_data::{self};
use eframe::egui;
use std::sync::Arc;
use tokio::sync::Mutex;

pub fn windows_run() -> Result<(), eframe::Error> {
    let options = eframe::NativeOptions {   // 配置窗口的初始参数
        // 设置窗口初始大小为400x300像素
        viewport: egui::ViewportBuilder::default().with_inner_size([400.0, 300.0]),
        ..Default::default()                // 其他参数保持默认值
    };
    // 启动原生窗口应用
    eframe::run_native(
        "济南公共交易网土地成交信息",                                // 窗口标题
        options,                                      // 传入配置选项
        Box::new(|cc| Ok(Box::new(MyApp::new(cc)))),  // 创建应用实例的闭包，_cc包含创建上下文信息
    )
}

// 定义分页信息结构体
#[derive(Default)]
struct PaginationInfo {
    current_page: usize,
    page_size: usize,
    total_pages: usize,
    total_records: usize
}

// 定义应用的主要结构体
#[derive(Default)]
struct MyApp {
    // 存储查询结果，使用Arc和Mutex实现线程安全
    notices_result: Option<Arc<Mutex<Vec<Notice>>>>,
    // 存储分页信息，使用Arc和Mutex实现线程安全
    pagination_info: Option<Arc<Mutex<(usize, usize)>>>, // (total_count, total_pages)
    // 分页相关状态
    pagination: PaginationInfo,
    // 区县相关状态
    canton_list: Vec<String>,
    selected_canton: String
}
// 为MyApp实现Default trait以提供默认初始化
impl MyApp {
    fn new(cc: &eframe::CreationContext<'_>) -> Self {
        tools::load_fonts(&cc.egui_ctx); // 初始化字体系统
        
        // 创建默认实例
        let mut app = Self {
            notices_result: None,
            pagination_info: None,
            pagination: PaginationInfo {
                current_page: 1,
                page_size: 20,
                total_pages: 1,
                total_records: 0
            },
            canton_list: vec![],
            selected_canton: "全部".to_string()
        };
        
        // 加载区县数据
        app.load_canton_data();
        
        app
    }
}
// 为MyApp实现eframe::App trait定义应用行为
// 为了演示目的，我们在每次update时更新总页数
// 在实际应用中，这应该通过消息机制或回调来完成
fn calculate_total_pages(total_records: usize, page_size: usize) -> usize {
    if page_size == 0 {
        1
    } else {
        (total_records + page_size - 1) / page_size
    }
}

impl eframe::App for MyApp {
    // 每帧调用的更新函数
    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
        // 从数据库查询结果中获取分页信息
        if let Some(pagination_info) = &self.pagination_info {
            if let Ok(pagination) = pagination_info.try_lock() {
                self.pagination.total_records = pagination.0;
                self.pagination.total_pages = pagination.1;
            }
        }
        
        egui::TopBottomPanel::top("top_panel").show(ctx, |ui| {
            ui.horizontal(|ui| {
                if ui.button("更新近期数据").clicked(){
                    // 创建一个线程来运行异步任务
                    std::thread::spawn(|| {
                        println!("开始更新近期数据...");
                        // 创建异步运行时并执行异步函数
                        match tokio::runtime::Runtime::new() {
                            Ok(runtime) => {
                                if let Err(e) = runtime.block_on(get_web_data::get_update_page()) {
                                    println!("获取数据失败: {:?}", e);
                                } else {
                                    println!("近期数据更新完成！");
                                }
                            },
                            Err(e) => println!("创建运行时失败: {:?}", e)
                        }
                    });
                }
                if ui.button("重新更新所有数据").clicked(){
                    // 创建一个线程来运行异步任务
                    std::thread::spawn(|| {
                        println!("开始更新所有数据...");
                        // 创建异步运行时并执行异步函数
                        match tokio::runtime::Runtime::new() {
                            Ok(runtime) => {
                                if let Err(e) = runtime.block_on(get_web_data::get_all_page()) {
                                    println!("获取所有数据失败: {:?}", e);
                                } else {
                                    println!("所有数据更新完成！");
                                }
                            },
                            Err(e) => println!("创建运行时失败: {:?}", e)
                        }
                    });
                }
                if ui.button("获取区县信息").clicked(){
                    // 创建一个线程来运行异步任务
                    std::thread::spawn(|| {
                        println!("开始获取区县信息...");
                        // 创建异步运行时并执行异步函数
                        match tokio::runtime::Runtime::new() {
                            Ok(runtime) => {
                                if let Err(e) = runtime.block_on(get_web_data::get_canton_info()) {
                                    println!("获取区县信息失败: {:?}", e);
                                } else {
                                    println!("区县信息获取完成！");
                                }
                            },
                            Err(e) => println!("创建运行时失败: {:?}", e)
                        }
                    });
                }
            });
        });
        
        egui::CentralPanel::default().show(ctx, |ui| {       // 创建中央面板（egui的主要布局组件）
              // 区县选择下拉框
                ui.horizontal(|ui| {
                    ui.label("选择区县:");
                    let original_selection = self.selected_canton.clone();
                    
                    egui::ComboBox::from_label("区县选择")
                        .selected_text(&self.selected_canton)
                        .width(150.0) // 设置固定宽度
                        .show_ui(ui, |ui| {
                            for canton in &self.canton_list {
                                ui.selectable_value(&mut self.selected_canton, canton.clone(), canton);
                            }
                        });
                    
                    // 在ComboBox外部检查选择是否改变，避免借用冲突
                    if self.selected_canton != original_selection {
                        // 当选择改变时，重新加载数据
                        self.pagination.current_page = 1; // 重置到第一页
                        self.load_data();
                    }
                });
                
            if ui.button("获取公告信息").clicked(){
                self.load_data();
            }
            
            // 先检查是否有数据
            let has_data = self.notices_result.is_some();
            
            // 显示表格
            if has_data {
                // 在单独的作用域中获取数据，避免长时间持有锁
                let notices_clone; // 存储克隆的数据
                if let Some(notices_result) = &self.notices_result {
                    let notices = notices_result.blocking_lock();
                    notices_clone = notices.clone();
                } else {
                    notices_clone = Vec::new();
                }
                
              
                if !notices_clone.is_empty() {
                    ui.separator();
                    ui.label(format!("查询结果: 共{}条记录", self.pagination.total_records));
                    
                    // 创建表格显示公告信息，使用正确的方式添加行横线
                    let frame = egui::Frame::new()
                        .stroke(egui::Stroke::new(1.0, egui::Color32::GRAY));
                    
                    frame.show(ui, |ui| {
                        egui_extras::TableBuilder::new(ui)
                            // 设置列
                            .column(egui_extras::Column::auto().resizable(true).clip(true))  // 公告日期
                            .column(egui_extras::Column::auto().resizable(true).clip(true))  // 区域
                            .column(egui_extras::Column::auto().resizable(true).clip(true))  // 文号
                            .column(egui_extras::Column::remainder().resizable(true))        // 公告名称
                            .striped(true)// 行间隔条纹
                            .vscroll(true)// 垂直滚动
                            .header(25.0, |mut header| {
                                header.col(|ui| { ui.heading("公告日期"); });
                                header.col(|ui| { ui.heading("区域"); });
                                header.col(|ui| { ui.heading("文号"); });
                                header.col(|ui| { ui.heading("公告名称"); });
                            })
                            .body(|mut body| {
                                // 显示每条公告记录
                                for notice in notices_clone.iter() {
                                    body.row(30.0, |mut row| {
                                        row.col(|ui| { ui.label(&notice.notice_date); });
                                        row.col(|ui| { ui.label(&notice.area); });
                                        row.col(|ui| { ui.label(&notice.identifier); });
                                        row.col(|ui| { ui.label(&notice.notice_name); });
                                    });
                                }
                            });
                    });
                    
                    // 添加分页控件
                    ui.separator();
                    ui.horizontal(|ui| {
                        // 上一页按钮
                        let prev_enabled = self.pagination.current_page > 1;
                        if ui.add_enabled(prev_enabled, egui::Button::new("上一页")).clicked() {
                            self.pagination.current_page -= 1;
                            self.load_data(); // 重新加载数据
                        }
                        
                        // 页码显示
                        ui.label(format!("第 {} 页 / 共 {} 页", self.pagination.current_page, self.pagination.total_pages));
                        
                        // 下一页按钮
                        let next_enabled = self.pagination.current_page < self.pagination.total_pages;
                        if ui.add_enabled(next_enabled, egui::Button::new("下一页")).clicked() {
                            self.pagination.current_page += 1;
                            self.load_data(); // 重新加载数据
                        }
                        
                        // 每页记录数选择
                        ui.label("每页:");
                        egui::ComboBox::from_label("")
                            .selected_text(format!("{}", self.pagination.page_size))
                            .show_ui(ui, |ui| {
                                for &size in &[10, 20, 50, 100] {
                                    let mut temp_size = self.pagination.page_size;
                                    if ui.selectable_value(&mut temp_size, size, format!("{}", size)).clicked() {
                                        self.pagination.page_size = temp_size;
                                        self.pagination.current_page = 1; // 重置到第一页
                                        self.load_data(); // 重新加载数据
                                    }
                                }
                            });
                    });
                } else {
                    ui.label("暂无数据");
                }
            } else {
                ui.label("请点击'获取公告信息'按钮查询数据");
            }
        });
    }
}

// 为MyApp实现数据加载方法
impl MyApp {
    // 加载区县数据的方法
    fn load_canton_data(&mut self) {
        match sqlite::create_db() {
            Ok(conn) => {
                // 查询canton_table表中的所有区县名称
                match query::get_all_cantons(&conn) {
                    Ok(cantons) => {
                        // 清空现有列表并添加"全部"选项
                        self.canton_list.clear();
                        
                        // 添加数据库中的区县名称
                        for canton in &cantons {
                            self.canton_list.push(canton.clone());
                        }
                        
                        // 将默认选中值设为查询结果的第一项
                        if let Some(first_canton) = cantons.first() {
                            self.selected_canton = first_canton.clone();
                        }
                        
                        println!("成功加载区县数据，共{}个区县", self.canton_list.len() - 1);
                    },
                    Err(e) => {
                        println!("加载区县数据失败: {:?}", e);
                        // 如果加载失败，只添加"全部"选项
                        self.canton_list = vec!["全部".to_string()];
                        self.selected_canton = "全部".to_string();
                    }
                }
            },
            Err(e) => {
                println!("数据库连接失败: {:?}", e);
                self.canton_list = vec!["全部".to_string()];
                self.selected_canton = "全部".to_string();
            }
        }
    }
    
    // 加载分页数据的方法
    fn load_data(&mut self) {
        // 获取当前的分页参数
        let page = self.pagination.current_page;
        let page_size = self.pagination.page_size;
        // 复制selected_canton的值，以便在线程中使用
        let selected_canton = self.selected_canton.clone();
        
        // 创建新的共享结果存储
        let notices_result = Arc::new(Mutex::new(Vec::new()));
        let pagination_info = Arc::new(Mutex::new((0, 0))); // (total_count, total_pages)
        
        // 复制引用以在新线程中使用
        let notices_result_clone = notices_result.clone();
        let pagination_info_clone = pagination_info.clone();
        
        // 创建一个线程来运行异步任务
        std::thread::spawn(move || {
            println!("开始获取公告信息...");
            // 使用Tokio运行时
            match tokio::runtime::Builder::new_multi_thread()
                .worker_threads(1)
                .enable_all()
                .build() {
                Ok(runtime) => {
                    // 先创建数据库连接
                    match sqlite::create_db() {
                        Ok(conn) => {
                            // 使用分页参数来获取数据
                            match query::get_notices_by_area_or_all(
                                &conn,
                                &PaginationParams {
                                    page: page as i64,
                                    page_size: page_size as i64,
                                },
                                // 如果选择了"全部"，则传入空字符串，否则传入选中的区县名称
                                if selected_canton == "全部" { "" } else { &selected_canton }
                            ) {
                                Ok(result) => {
                                    // 保存查询结果
                                    let mut notices = notices_result_clone.blocking_lock();
                                    *notices = result.data.clone();
                                    
                                    // 保存分页信息
                                    let mut pagination = pagination_info_clone.blocking_lock();
                                    *pagination = (result.total_count as usize, result.total_pages as usize);
                                        
                                    // 打印日志
                                    println!("公告信息获取完成，共{}条记录，总页数{}！", result.total_count, result.total_pages);
                                    
                                    // 在实际应用中，这里应该通过某种消息机制通知主线程更新UI
                                    // 例如使用crossbeam_channel或其他方式传递pagination信息
                                    // 由于这是一个演示，我们暂时在主线程中处理UI更新
                                },
                                Err(e) => println!("查询公告信息失败: {:?}", e)
                            }
                        },
                        Err(e) => println!("数据库连接失败: {:?}", e)
                    }
                },
                Err(e) => println!("创建运行时失败: {:?}", e)
            }
        });
        
        // 更新UI状态
        self.notices_result = Some(notices_result);
        self.pagination_info = Some(pagination_info);
    }
}

